home *** CD-ROM | disk | FTP | other *** search
/ X User Tools / X User Tools (O'Reilly and Associates)(1994).ISO / sources / xcalc / actions.c next >
C/C++ Source or Header  |  1994-09-27  |  10KB  |  542 lines
  1. /*
  2.  * $XConsortium: actions.c,v 1.8 91/03/22 18:27:15 converse Exp $
  3.  *
  4.  * actions.c - externally available procedures for xcalc
  5.  * 
  6.  * Copyright 1989 by the Massachusetts Institute of Technology
  7.  *
  8.  * Permission to use, copy, modify, and distribute this software and its
  9.  * documentation for any purpose and without fee is hereby granted, provided 
  10.  * that the above copyright notice appear in all copies and that both that 
  11.  * copyright notice and this permission notice appear in supporting 
  12.  * documentation, and that the name of M.I.T. not be used in advertising
  13.  * or publicity pertaining to distribution of the software without specific, 
  14.  * written prior permission. M.I.T. makes no representations about the 
  15.  * suitability of this software for any purpose.  It is provided "as is"
  16.  * without express or implied warranty.
  17.  *
  18.  * M.I.T. DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL
  19.  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL M.I.T.
  20.  * BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  21.  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION
  22.  * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
  23.  * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  24.  *
  25.  * Author:  Donna Converse, MIT X Consortium
  26.  */
  27.  
  28. #include <X11/Intrinsic.h>
  29. #include <setjmp.h>
  30. #include "xcalc.h"
  31. extern int rpn;
  32. extern Atom wm_delete_window;
  33. extern int pre_op();
  34. extern void post_op(), Quit(), ringbell(), do_select();
  35.  
  36. #ifndef IEEE
  37. extern    jmp_buf env;
  38. extern void fail_op();
  39. #define XCALC_PRE_OP(keynum) { if (pre_op(keynum)) return; \
  40.                if (setjmp (env)) {fail_op(); return;}}
  41. #else
  42. #define XCALC_PRE_OP(keynum) if (pre_op(keynum)) return;
  43. #endif
  44.  
  45. /*ARGSUSED*/
  46. void add(w, e, vector, count)
  47.     Widget    w;
  48.     XEvent    *e;
  49.     String    *vector;
  50.     Cardinal    *count;
  51. {
  52.     XCALC_PRE_OP(kADD);
  53.     rpn ? twof(kADD) : twoop(kADD);
  54.     post_op();
  55. }
  56.  
  57. /*ARGSUSED*/
  58. void back(w, e, vector, count)
  59.     Widget    w;
  60.     XEvent    *e;
  61.     String    *vector;
  62.     Cardinal    *count;
  63. {
  64.     XCALC_PRE_OP(kBKSP);
  65.     bkspf();
  66.     post_op();
  67. }
  68.  
  69. /*ARGSUSED*/
  70. void bell(w, e, vector, count)
  71.     Widget    w;
  72.     XEvent    *e;
  73.     String    *vector;
  74.     Cardinal    *count;
  75. {
  76.     ringbell();
  77. }
  78.  
  79. /*ARGSUSED*/
  80. void clearit(w, e, vector, count)
  81.     Widget    w;
  82.     XEvent    *e;
  83.     String    *vector;
  84.     Cardinal    *count;
  85. {
  86.     XCALC_PRE_OP(kCLR);
  87.     clearf();
  88.     post_op();
  89. }
  90.    
  91. /*ARGSUSED*/
  92. void cosine(w, e, vector, count)
  93.     Widget    w;
  94.     XEvent    *e;
  95.     String    *vector;
  96.     Cardinal    *count;
  97. {
  98.     XCALC_PRE_OP(kCOS);
  99.     oneop(kCOS);
  100.     post_op();
  101. }
  102.  
  103. /*ARGSUSED*/
  104. void decimal(w, e, vector, count)
  105.     Widget    w;
  106.     XEvent    *e;
  107.     String    *vector;
  108.     Cardinal    *count;
  109. {
  110.     XCALC_PRE_OP(kDEC);
  111.     decf();
  112.     post_op();
  113. }
  114.  
  115. /*ARGSUSED*/
  116. void degree(w, e, vector, count)
  117.     Widget    w;
  118.     XEvent    *e;
  119.     String    *vector;
  120.     Cardinal    *count;
  121. {
  122.     XCALC_PRE_OP(kDRG);
  123.     drgf();
  124.     post_op();
  125. }
  126.  
  127. /*ARGSUSED*/
  128. void digit(w, e, vector, count)
  129.     Widget    w;
  130.     XEvent    *e;
  131.     String    *vector;
  132.     Cardinal    *count;
  133. {
  134.     switch (vector[0][0])
  135.     {
  136.       case '1':    XCALC_PRE_OP(kONE); numeric(kONE); break;
  137.       case '2': XCALC_PRE_OP(kTWO); numeric(kTWO); break;
  138.       case '3': XCALC_PRE_OP(kTHREE); numeric(kTHREE); break;
  139.       case '4': XCALC_PRE_OP(kFOUR); numeric(kFOUR); break;
  140.       case '5': XCALC_PRE_OP(kFIVE); numeric(kFIVE); break;
  141.       case '6': XCALC_PRE_OP(kSIX); numeric(kSIX); break;
  142.       case '7': XCALC_PRE_OP(kSEVEN); numeric(kSEVEN); break;
  143.       case '8': XCALC_PRE_OP(kEIGHT); numeric(kEIGHT); break;
  144.       case '9': XCALC_PRE_OP(kNINE); numeric(kNINE); break;
  145.       case '0': XCALC_PRE_OP(kZERO); numeric(kZERO); break;
  146.     }
  147.     post_op();
  148. }
  149.  
  150. /*ARGSUSED*/
  151. void divide(w, e, vector, count)
  152.     Widget    w;
  153.     XEvent    *e;
  154.     String    *vector;
  155.     Cardinal    *count;
  156. {
  157.     XCALC_PRE_OP(kDIV);
  158.     rpn  ? twof(kDIV) : twoop(kDIV);
  159.     post_op();
  160. }
  161.  
  162. /*ARGSUSED*/
  163. void e(w, ev, vector, count)
  164.     Widget    w;
  165.     XEvent    *ev;
  166.     String    *vector;
  167.     Cardinal    *count;
  168. {
  169.     XCALC_PRE_OP(kE);
  170.     oneop(kE);
  171.     post_op();
  172. }
  173.  
  174. /*ARGSUSED*/
  175. void enter(w, e, vector, count)
  176.     Widget    w;
  177.     XEvent    *e;
  178.     String    *vector;
  179.     Cardinal    *count;
  180. {
  181.     XCALC_PRE_OP(kENTR);
  182.     entrf();
  183.     post_op();
  184. }
  185.  
  186. /*ARGSUSED*/
  187. void epower(w, e, vector, count)
  188.     Widget    w;
  189.     XEvent    *e;
  190.     String    *vector;
  191.     Cardinal    *count;
  192. {
  193.     XCALC_PRE_OP(kEXP);
  194.     oneop(kEXP);
  195.     post_op();
  196. }
  197.  
  198. /*ARGSUSED*/
  199. void equal(w, e, vector, count)
  200.     Widget    w;
  201.     XEvent    *e;
  202.     String    *vector;
  203.     Cardinal    *count;
  204. {
  205.     XCALC_PRE_OP(kEQU);
  206.     equf();
  207.     post_op();
  208. }
  209.  
  210. /*ARGSUSED*/
  211. void exchange(w, e, vector, count)
  212.     Widget    w;
  213.     XEvent    *e;
  214.     String    *vector;
  215.     Cardinal    *count;
  216. {
  217.     XCALC_PRE_OP(kEXC);
  218.     oneop(kEXC);
  219.     post_op();
  220. }
  221.    
  222. /*ARGSUSED*/
  223. void factorial(w, e, vector, count)
  224.     Widget    w;
  225.     XEvent    *e;
  226.     String    *vector;
  227.     Cardinal    *count;
  228. {
  229.     XCALC_PRE_OP(kFACT);
  230.     oneop(kFACT);
  231.     post_op();
  232. }
  233.  
  234. /*ARGSUSED*/
  235. void inverse(w, e, vector, count)
  236.     Widget    w;
  237.     XEvent    *e;
  238.     String    *vector;
  239.     Cardinal    *count;
  240. {
  241.     XCALC_PRE_OP(kINV);
  242.     invf();
  243.     post_op();
  244. }
  245.    
  246. /*ARGSUSED*/
  247. void leftParen(w, e, vector, count)
  248.     Widget    w;
  249.     XEvent    *e;
  250.     String    *vector;
  251.     Cardinal    *count;
  252. {
  253.     XCALC_PRE_OP(kLPAR);
  254.     lparf();
  255.     post_op();
  256. }
  257.    
  258. /*ARGSUSED*/
  259. void logarithm(w, e, vector, count)
  260.     Widget    w;
  261.     XEvent    *e;
  262.     String    *vector;
  263.     Cardinal    *count;
  264. {
  265.     XCALC_PRE_OP(kLOG);
  266.     oneop(kLOG);
  267.     post_op();
  268. }
  269.  
  270. /*ARGSUSED*/
  271. void multiply(w, e, vector, count)
  272.     Widget    w;
  273.     XEvent    *e;
  274.     String    *vector;
  275.     Cardinal    *count;
  276. {
  277.     XCALC_PRE_OP(kMUL);
  278.     rpn ? twof(kMUL) : twoop(kMUL);
  279.     post_op();
  280. }
  281.    
  282. /*ARGSUSED*/
  283. void naturalLog(w, e, vector, count)
  284.     Widget    w;
  285.     XEvent    *e;
  286.     String    *vector;
  287.     Cardinal    *count;
  288. {
  289.     XCALC_PRE_OP(kLN);
  290.     oneop(kLN);
  291.     post_op();
  292. }
  293.    
  294. /*ARGSUSED*/
  295. void negate(w, e, vector, count)
  296.     Widget    w;
  297.     XEvent    *e;
  298.     String    *vector;
  299.     Cardinal    *count;
  300. {
  301.     XCALC_PRE_OP(kNEG);
  302.     negf();
  303.     post_op();
  304. }
  305.  
  306. /*ARGSUSED*/
  307. void nop(w, e, vector, count)
  308.     Widget    w;
  309.     XEvent    *e;
  310.     String    *vector;
  311.     Cardinal    *count;
  312. {
  313.     ringbell();
  314. }
  315.  
  316. /*ARGSUSED*/
  317. void off(w, e, vector, count)
  318.     Widget    w;
  319.     XEvent    *e;
  320.     String    *vector;
  321.     Cardinal    *count;
  322. {
  323.     XCALC_PRE_OP(kOFF);
  324.     offf();
  325.     post_op();
  326. }
  327.    
  328. /*ARGSUSED*/
  329. void pi(w, e, vector, count)
  330.     Widget    w;
  331.     XEvent    *e;
  332.     String    *vector;
  333.     Cardinal    *count;
  334. {
  335.     XCALC_PRE_OP(kPI);
  336.     oneop(kPI);
  337.     post_op();
  338. }
  339.    
  340. /*ARGSUSED*/
  341. void power(w, e, vector, count)
  342.     Widget    w;
  343.     XEvent    *e;
  344.     String    *vector;
  345.     Cardinal    *count;
  346. {
  347.     XCALC_PRE_OP(kPOW);
  348.     rpn ? twof(kPOW) : twoop(kPOW);
  349.     post_op();
  350. }
  351.  
  352. /*ARGSUSED*/
  353. void quit(w, e, vector, count)
  354.     Widget    w;
  355.     XEvent    *e;
  356.     String    *vector;
  357.     Cardinal    *count;
  358. {
  359.     if (e->type == ClientMessage && e->xclient.data.l[0] != wm_delete_window)
  360.     ringbell();
  361.     else
  362.     Quit();
  363. }
  364.  
  365. /*ARGSUSED*/
  366. void recall(w, e, vector, count)
  367.     Widget    w;
  368.     XEvent    *e;
  369.     String    *vector;
  370.     Cardinal    *count;
  371. {
  372.     XCALC_PRE_OP(kRCL);
  373.     rpn ? memf(kRCL) : oneop(kRCL);
  374.     post_op();
  375. }
  376.     
  377. /*ARGSUSED*/
  378. void reciprocal(w, e, vector, count)
  379.     Widget    w;
  380.     XEvent    *e;
  381.     String    *vector;
  382.     Cardinal    *count;
  383. {
  384.     XCALC_PRE_OP(kRECIP);
  385.     oneop(kRECIP);
  386.     post_op();
  387. }
  388.    
  389. /*ARGSUSED*/
  390. void rightParen(w, e, vector, count)
  391.     Widget    w;
  392.     XEvent    *e;
  393.     String    *vector;
  394.     Cardinal    *count;
  395. {
  396.     XCALC_PRE_OP(kRPAR);
  397.     rparf();
  398.     post_op();
  399. }
  400.    
  401. /*ARGSUSED*/
  402. void roll(w, e, vector, count)
  403.     Widget    w;
  404.     XEvent    *e;
  405.     String    *vector;
  406.     Cardinal    *count;
  407. {
  408.     XCALC_PRE_OP(kROLL);
  409.     rollf();
  410.     post_op();
  411. }
  412.  
  413. /*ARGSUSED*/
  414. void scientific(w, e, vector, count)
  415.     Widget    w;
  416.     XEvent    *e;
  417.     String    *vector;
  418.     Cardinal    *count;
  419. {
  420.     XCALC_PRE_OP(kEE);
  421.     eef();
  422.     post_op();
  423. }
  424.  
  425. /*ARGSUSED*/
  426. void selection(w, e, vector, count)
  427.     Widget    w;
  428.     XEvent    *e;
  429.     String    *vector;
  430.     Cardinal    *count;
  431. {
  432.     do_select(((XButtonReleasedEvent *)e)->time);
  433. }
  434.  
  435. /*ARGSUSED*/
  436. void sine(w, e, vector, count)
  437.     Widget    w;
  438.     XEvent    *e;
  439.     String    *vector;
  440.     Cardinal    *count;
  441. {
  442.     XCALC_PRE_OP(kSIN);
  443.     oneop(kSIN);
  444.     post_op();
  445. }
  446.  
  447. /*ARGSUSED*/
  448. void square(w, e, vector, count)
  449.     Widget    w;
  450.     XEvent    *e;
  451.     String    *vector;
  452.     Cardinal    *count;
  453. {
  454.     XCALC_PRE_OP(kSQR);
  455.     oneop(kSQR);
  456.     post_op();
  457. }
  458.  
  459. /*ARGSUSED*/
  460. void squareRoot(w, e, vector, count)
  461.     Widget    w;
  462.     XEvent    *e;
  463.     String    *vector;
  464.     Cardinal    *count;
  465. {
  466.     XCALC_PRE_OP(kSQRT);
  467.     oneop(kSQRT);
  468.     post_op();
  469. }
  470.    
  471. /*ARGSUSED*/
  472. void store(w, e, vector, count)
  473.     Widget    w;
  474.     XEvent    *e;
  475.     String    *vector;
  476.     Cardinal    *count;
  477. {
  478.     XCALC_PRE_OP(kSTO);
  479.     rpn ? memf(kSTO) : oneop(kSTO);
  480.     post_op();
  481. }
  482.  
  483. /*ARGSUSED*/
  484. void subtract(w, e, vector, count)
  485.     Widget    w;
  486.     XEvent    *e;
  487.     String    *vector;
  488.     Cardinal    *count;
  489. {
  490.     XCALC_PRE_OP(kSUB);
  491.     rpn ? twof(kSUB) : twoop(kSUB);
  492.     post_op();
  493. }
  494.    
  495. /*ARGSUSED*/
  496. void sum(w, e, vector, count)
  497.     Widget    w;
  498.     XEvent    *e;
  499.     String    *vector;
  500.     Cardinal    *count;
  501. {
  502.     XCALC_PRE_OP(kSUM);
  503.     rpn ? memf(kSUM) : oneop(kSUM);
  504.     post_op();
  505. }
  506.    
  507. /*ARGSUSED*/
  508. void tangent(w, e, vector, count)
  509.     Widget    w;
  510.     XEvent    *e;
  511.     String    *vector;
  512.     Cardinal    *count;
  513. {
  514.     XCALC_PRE_OP(kTAN);
  515.     oneop(kTAN);
  516.     post_op();
  517. }
  518.    
  519. /*ARGSUSED*/
  520. void tenpower(w, e, vector, count)
  521.     Widget    w;
  522.     XEvent    *e;
  523.     String    *vector;
  524.     Cardinal    *count;
  525. {
  526.     XCALC_PRE_OP(k10X);
  527.     oneop(k10X);
  528.     post_op();
  529. }
  530.    
  531. /*ARGSUSED*/
  532. void XexchangeY(w, e, vector, count)
  533.     Widget    w;
  534.     XEvent    *e;
  535.     String    *vector;
  536.     Cardinal    *count;
  537. {
  538.     XCALC_PRE_OP(kXXY);
  539.     twof(kXXY);
  540.     post_op();
  541. }
  542.